package pac

// import (
// 	"fmt"
// 	"strconv"
// 	"time"

// 	"slgw_web/serial/dto"
// 	"slgw_web/serial/util"

// 	db "slgw_web/application/gormdb"

// 	"github.com/goburrow/modbus"
// 	models "openzbox.com/frame/echo/models/sl_gw01"
// )

// var (
// 	test []dto.Test
// )

// func init() {
// 	GetSerialInit()
// 	GetSerial_SlavelInit()
// 	Serial_Slave_DetailInit()
// 	RTUClient()
// }

// func CollectNew() {

// }

// var is int

// func RTUClient() {
// 	// 创建Modbus主机
// 	test = test[:0]
// 	for _, data := range util.Serial {
// 		if data.Agreement == "1" { //modbus模式
// 			baudRate, err := strconv.Atoi(data.BAD)
// 			if err != nil {
// 				util.Error(data.ComName + "的波特率转换失败")
// 			}
// 			dataBits, err := strconv.Atoi(data.DAB)
// 			if err != nil {
// 				util.Error(data.ComName + "的数据位转换失败")
// 			}
// 			stopBits, err := strconv.Atoi(data.STO)
// 			if err != nil {
// 				util.Error(data.ComName + "的停止位转换失败")
// 			}
// 			clients := modbus.NewRTUClientHandler(data.ComName)
// 			clients.BaudRate = baudRate
// 			clients.DataBits = dataBits
// 			clients.Parity = data.CHC
// 			clients.StopBits = stopBits
// 			clients.Timeout = 2 * time.Second
// 			var clientClients = modbus.NewClient(clients)
// 			test1 := dto.Test{
// 				ClientClient: clientClients,
// 				DataID:       data.ID,
// 				ComName:      data.ComName,
// 				Clients:      clients,
// 				TPITV:        data.TPITV,
// 				I:            is,
// 			}
// 			is++
// 			test = append(test, test1)
// 		}
// 	}
// }

// // 定时查询
// func GetDataTime() {

// 	for i := range test {
// 		for _, data2 := range util.Serial_Slave {
// 			if data2.Serial_ID == test[i].DataID {
// 				//获取该串口的地址位
// 				slaveIds, err := strconv.Atoi(data2.ModbusSlaveID)
// 				if err != nil {
// 					util.Error(data2.Name + "地址位转换失败")
// 				}
// 				slaveID := byte(slaveIds)
// 				test[i].Clients.SlaveId = slaveID // 打开该串口下的指定地址位
// 				err = test[i].Clients.Connect()
// 				if err != nil {
// 					test[i].Clients.Close()
// 					// util.MyPanic("打开该串口下的指定地址位失败", err)
// 					util.Error("打开'" + test[i].ComName + "." + data2.Name + "'失败，请检查配置情况:<br>" + err.Error())
// 					continue
// 				}

// 					var maxID int64 = 0 // 获取的最大寄存器地址
// 					for _, item := range util.Serial_Slave_Detail {
// 						if item.Serial_ID == test[i].DataID && item.Serial_Slave_ID == data2.ID && item.Type == data3 {
// 							if *item.CollectAddressID > maxID {
// 								maxID = *item.CollectAddressID
// 							}
// 						}
// 					}
// 					maxID += 1
// 					address := uint16(0)      // 寄存器起始地址
// 					quantity := uint16(maxID) // 寄存器数量
// 					if data3 == 1 {
// 						//读功能码01
// 						results, err := test[i].ClientClient.ReadCoils(address, quantity)
// 						if err != nil {
// 							util.Error("'" + test[i].ComName + "." + data2.Name + ".功能码1'读取数据失败，请检查配置情况:<br>" + err.Error())
// 							for _, dataTest2 := range test {
// 								dataTest2.Clients.Close()
// 							}
// 							//重新尝试读取寄存器
// 							RTUClient()
// 							test[i].Clients.SlaveId = slaveID
// 							err = test[i].Clients.Connect()
// 							if err != nil {
// 								util.Error("再次打开'" + test[i].ComName + "." + data2.Name + "'失败，请检查配置情况:<br>" + err.Error())
// 							}
// 							results, err = test[i].ClientClient.ReadCoils(address, quantity)
// 							if err != nil {
// 								util.Error("'" + test[i].ComName + "." + data2.Name + ".功能码1'重新读取数据失败，请检查配置情况:<br>" + err.Error())
// 							} else {
// 								if len(results) > 0 {
// 									binaryStr := BytesToBinaryString(results)
// 									hexString := GetBinaryString(binaryStr)
// 									AddData(data2.Serial_ID, data2.ID, data3, hexString)
// 								} else {
// 									fmt.Println("quantityerror", quantity)
// 									detailName := deleteArray(data2.Serial_ID, data2.ID, data3, maxID-1)
// 									data := "串口配置错误：" + test[i].ComName + "." + data2.Name + ".功能码1" + "." + detailName
// 									util.Error(data)
// 								}
// 							}
// 						} else {
// 							if len(results) > 0 {
// 								binaryStr := BytesToBinaryString(results)
// 								hexString := GetBinaryString(binaryStr)
// 								AddData(data2.Serial_ID, data2.ID, data3, hexString)
// 							} else {
// 								fmt.Println("quantityerror", quantity)
// 								detailName := deleteArray(data2.Serial_ID, data2.ID, data3, maxID-1)
// 								data := "串口配置错误：" + test[i].ComName + "." + data2.Name + ".功能码1" + "." + detailName
// 								util.Error(data)
// 							}
// 						}

// 					} else if data3 == 2 {
// 						//读功能码02
// 						results, err := test[i].ClientClient.ReadDiscreteInputs(address, quantity)
// 						if err != nil {

// 							util.Error("'" + test[i].ComName + "." + data2.Name + ".功能码2'读取数据失败，请检查配置情况:<br>" + err.Error())
// 							for _, dataTest2 := range test {
// 								dataTest2.Clients.Close()
// 							}
// 							//重新尝试读取寄存器
// 							RTUClient()
// 							test[i].Clients.SlaveId = slaveID
// 							err = test[i].Clients.Connect()
// 							if err != nil {
// 								util.Error("再次打开'" + test[i].ComName + "." + data2.Name + "'失败，请检查配置情况:<br>" + err.Error())
// 							}
// 							results, err = test[i].ClientClient.ReadDiscreteInputs(address, quantity)
// 							if err != nil {
// 								util.Error("'" + test[i].ComName + "." + data2.Name + ".功能码2'重新读取数据失败，请检查配置情况:<br>" + err.Error())
// 							} else {
// 								if len(results) > 0 {
// 									binaryStr := BytesToBinaryString(results)
// 									hexString := GetBinaryString(binaryStr)
// 									AddData(data2.Serial_ID, data2.ID, data3, hexString)
// 								} else {
// 									detailName := deleteArray(data2.Serial_ID, data2.ID, data3, maxID-1)
// 									data := "串口配置错误：" + test[i].ComName + "." + data2.Name + ".功能码2" + "." + detailName
// 									util.Error(data)
// 								}
// 							}
// 						} else {
// 							if len(results) > 0 {
// 								binaryStr := BytesToBinaryString(results)
// 								hexString := GetBinaryString(binaryStr)
// 								AddData(data2.Serial_ID, data2.ID, data3, hexString)
// 							} else {
// 								detailName := deleteArray(data2.Serial_ID, data2.ID, data3, maxID-1)
// 								data := "串口配置错误：" + test[i].ComName + "." + data2.Name + ".功能码2" + "." + detailName
// 								util.Error(data)
// 							}
// 						}

// 					} else if data3 == 3 {
// 						//读功能码03
// 						results, err := test[i].ClientClient.ReadHoldingRegisters(address, quantity)
// 						if err != nil {

// 							util.Error("'" + test[i].ComName + "." + data2.Name + ".功能码3'读取数据失败，请检查配置情况:<br>" + err.Error())
// 							for _, dataTest2 := range test {
// 								dataTest2.Clients.Close()
// 							}
// 							//重新尝试读取寄存器
// 							RTUClient()
// 							test[i].Clients.SlaveId = slaveID
// 							err = test[i].Clients.Connect()
// 							if err != nil {
// 								util.Error("再次打开'" + test[i].ComName + "." + data2.Name + "'失败，请检查配置情况:<br>" + err.Error())
// 							}
// 							results, err = test[i].ClientClient.ReadHoldingRegisters(address, quantity)
// 							if err != nil {
// 								// util.MyPanic(dataid+":重连ReadHoldingRegisters失败", err)
// 								util.Error("'" + test[i].ComName + "." + data2.Name + ".功能码3'重新读取数据失败，请检查配置情况:<br>" + err.Error())
// 							} else {
// 								if len(results) > 0 {
// 									hexString := Ab2hex(results)
// 									AddData(data2.Serial_ID, data2.ID, data3, hexString)
// 								} else {
// 									detailName := deleteArray(data2.Serial_ID, data2.ID, data3, maxID-1)
// 									data := "串口配置错误：" + test[i].ComName + "." + data2.Name + ".功能码3" + "." + detailName
// 									util.Error(data)
// 								}
// 							}
// 						} else {
// 							if len(results) > 0 {
// 								hexString := Ab2hex(results)
// 								AddData(data2.Serial_ID, data2.ID, data3, hexString)
// 							} else {
// 								detailName := deleteArray(data2.Serial_ID, data2.ID, data3, maxID-1)
// 								data := "串口配置错误：" + test[i].ComName + "." + data2.Name + ".功能码3" + "." + detailName
// 								util.Error(data)
// 							}
// 						}

// 					} else if data3 == 4 {
// 						//读功能码04
// 						results, err := test[i].ClientClient.ReadInputRegisters(address, quantity)
// 						if err != nil {
// 							util.Error("'" + test[i].ComName + "." + data2.Name + ".功能码4'读取数据失败，请检查配置情况:<br>" + err.Error())
// 							for _, dataTest2 := range test {
// 								dataTest2.Clients.Close()
// 							}
// 							//重新尝试读取寄存器
// 							RTUClient()
// 							test[i].Clients.SlaveId = slaveID
// 							err = test[i].Clients.Connect()
// 							if err != nil {
// 								util.Error("再次打开'" + test[i].ComName + "." + data2.Name + "'失败，请检查配置情况:<br>" + err.Error())
// 								continue
// 							}
// 							results, err = test[i].ClientClient.ReadInputRegisters(address, quantity)
// 							if err != nil {
// 								util.Error("'" + test[i].ComName + "." + data2.Name + ".功能码4'重新读取数据失败，请检查配置情况:<br>" + err.Error())
// 								continue
// 							} else {
// 								if len(results) > 0 {
// 									hexString := Ab2hex(results)
// 									AddData(data2.Serial_ID, data2.ID, data3, hexString)
// 								} else {
// 									detailName := deleteArray(data2.Serial_ID, data2.ID, data3, maxID-1)
// 									data := "串口配置错误：" + test[i].ComName + "." + data2.Name + ".功能码3" + "." + detailName
// 									util.Error(data)
// 								}
// 							}
// 						} else {
// 							if len(results) > 0 {
// 								hexString := Ab2hex(results)
// 								AddData(data2.Serial_ID, data2.ID, data3, hexString)
// 							} else {
// 								detailName := deleteArray(data2.Serial_ID, data2.ID, data3, maxID-1)
// 								data := "串口配置错误：" + test[i].ComName + "." + data2.Name + ".功能码3" + "." + detailName
// 								util.Error(data)
// 							}
// 						}

// 					}
// 				}	for _, data3 := range GetTypesBySerialSlaveID(data2.ID) {

// 			}
// 		}
// 		//fmt.Println("collectDataList2", collectDataList)
// 	}
// }

// // 把出错的串口功能码去除
// func deleteArray(serial_ID int64, serial_Slave_ID int64, types int64, collectAddressID int64) string {
// 	for i, item := range util.Serial_Slave_Detail {
// 		if item.Serial_ID == serial_ID && item.Serial_Slave_ID == serial_Slave_ID && item.Type == types && *item.CollectAddressID == collectAddressID {
// 			util.Serial_Slave_Detail = append(util.Serial_Slave_Detail[:i], util.Serial_Slave_Detail[i+1:]...)
// 			return item.Name
// 			//break
// 		}
// 	}
// 	return ""
// }

// // 将获取的数据插入对应的位置
// func AddData(serial_ID int64, serial_Slave_ID int64, types int64, collectData string) {
// 	// fmt.Println("adddata", serial_ID, serial_Slave_ID, types, collectData)
// 	for i := 0; i < len(util.Serial_Slave_Detail); i++ {
// 		data := util.Serial_Slave_Detail[i]
// 		if data.Serial_ID == serial_ID && data.Serial_Slave_ID == serial_Slave_ID && data.Type == types {
// 			cdata := collectData[(*data.CollectAddressID * 4) : *data.CollectAddressID*4+4] //需要采集位置的数据
// 			test1 := dto.Serial_Slave_Detail_Cache{
// 				ID:               data.ID,
// 				Serial_ID:        data.Serial_ID,
// 				Serial_Slave_ID:  data.Serial_Slave_ID,
// 				CollectAddressID: *data.CollectAddressID,
// 				Type:             data.Type,
// 				Value:            cdata,
// 				CreateTime:       time.Now().Format("2006-01-02 15:04:05"),
// 			}
// 			// 在 append 之前，遍历 collectDataListNew，根据 ID 判断是否需要覆盖
// 			updated := false
// 			for i, data := range util.CollectDataList {
// 				if data.ID == test1.ID {
// 					// 找到相同 ID 的元素，进行覆盖
// 					util.CollectDataList[i] = test1
// 					updated = true
// 					break
// 				}
// 			}
// 			// 如果没有找到相同 ID 的元素，进行追加
// 			if !updated {
// 				util.CollectDataList = append(util.CollectDataList, test1)
// 			}
// 			//collectDataListNew = append(collectDataListNew, test1)
// 		}
// 		// if len(collectDataListNew) > 0 && len(util.Serial_Slave_Detail) == len(collectDataListNew) {
// 		// 	//清空重置
// 		// 	collectDataList = collectDataListNew
// 		// 	collectDataListNew = collectDataList[:0]

// 		// }
// 	}
// }

// // 对应开启的功能码 [3,4]
// func GetTypesBySerialSlaveID(serialSlaveID int64) []int64 {
// 	var types []int64
// 	for _, item := range util.Serial_Slave_Detail {
// 		if item.Serial_Slave_ID == serialSlaveID {
// 			types = append(types, item.Type)
// 		}
// 	}
// 	type2 := RemoveDuplicates(types)
// 	return type2
// }

// // 十进制转为8位的二进制 功能码1和2使用 比如[66 68] 转为  0100 0010 0100 0100
// func BytesToBinaryString(bytes []byte) string {
// 	binaryString := ""
// 	for _, b := range bytes {
// 		c := fmt.Sprintf("%08b", b)
// 		binaryString += ReverseBinary(c) //比如 0100 0010 0100 0100   转为 0100 0010 0010 0010

// 	}
// 	return binaryString
// }

// // 将二进制倒序排 功能码1和2使用  比如 1234 转为 4321
// func ReverseBinary(binaryStr string) string {
// 	var reversedBinary string
// 	for i := len(binaryStr) - 1; i >= 0; i-- {
// 		reversedBinary += string(binaryStr[i])
// 	}
// 	return reversedBinary
// }

// // 将每一个位转成4位二进制 功能码1和2使用 比如1101 转为 0001 0001 0000 0001
// func GetBinaryString(a string) string {

// 	c := ""
// 	for i := 0; i < len(a); i++ {
// 		b, _ := strconv.ParseInt(a[i:i+1], 10, 64)
// 		c += fmt.Sprintf("%04b", b)
// 	}
// 	return c
// }

// // 串口主设置
// func GetSerialInit() {
// 	Serial := []models.Serial{}
// 	db := db.GetDB()
// 	//查询所有文章,以及文章的分类Preload
// 	db.Preload("Serial_Slave").Preload("Serial_Slave.Serial_Slave_Detail").Find(&Serial)

// 	util.Serial = Serial
// }

// // 串口设备设置
// func GetSerial_SlavelInit() {
// 	db := db.GetDB()
// 	var data []models.Serial_Slave
// 	db.Find(&data)
// 	if len(data) == 0 {
// 		util.Error("串口设备数据未配置")
// 	}
// 	util.Serial_Slave = data
// }

// // 串口设备功能码设置
// func Serial_Slave_DetailInit() {
// 	db := db.GetDB()
// 	var data []models.Serial_Slave_Detail
// 	db.Find(&data)
// 	if len(data) == 0 {
// 		util.Error("串口设备功能码数据未配置")
// 	}
// 	util.Serial_Slave_Detail = data
// }
